// Emacs style mode select	 -*- C++ -*-
//-----------------------------------------------------------------------------
//
// $Id:$
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This source is available for distribution and/or modification
// only under the terms of the DOOM Source Code License as
// published by id Software. All rights reserved.
//
// The source is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
// for more details.
//
// DESCRIPTION:	 none
//		Implements special effects:
//		Texture animation, height or lighting changes
//		 according to adjacent sectors, respective
//		 utility functions, etc.
//
//-----------------------------------------------------------------------------


#ifndef __P_SPEC__
#define __P_SPEC__


//
// End-level timer (-TIMER option)
//
extern	boolean levelTimer;
extern	int		levelTimeCount;


//		Define values for map objects
#define MO_TELEPORTMAN			14


// at game start
void	P_InitPicAnims (void);

// at map load
void	P_SpawnSpecials (void);

// every tic
void	P_UpdateSpecials (void);

// when needed
boolean
P_UseSpecialLine
( mobj_t*		thing,
  line_t*		line,
  int			side );

void
P_ShootSpecialLine
( mobj_t*		thing,
  line_t*		line );

void
P_CrossSpecialLine
( int			linenum,
  int			side,
  mobj_t*		thing );

void	P_PlayerInSpecialSector (player_t* player);

int
twoSided
( int			sector,
  int			line );

sector_t*
getSector
( int			currentSector,
  int			line,
  int			side );

side_t*
getSide
( int			currentSector,
  int			line,
  int			side );

fixed_t P_FindLowestFloorSurrounding(sector_t* sec);
fixed_t P_FindHighestFloorSurrounding(sector_t* sec);

fixed_t
P_FindNextHighestFloor
( sector_t*		sec,
  int			currentheight );

fixed_t P_FindLowestCeilingSurrounding(sector_t* sec);
fixed_t P_FindHighestCeilingSurrounding(sector_t* sec);

int
P_FindSectorFromLineTag
( line_t*		line,
  int			start );

int
P_FindMinSurroundingLight
( sector_t*		sector,
  int			max );

sector_t*
getNextSector
( line_t*		line,
  sector_t*		sec );


//
// SPECIAL
//
int EV_DoDonut(line_t* line);



//
// P_LIGHTS
//
typedef struct
{
    thinker_t	thinker;
    sector_t*	sector;
    int			count;
    int			maxlight;
    int			minlight;

} fireflicker_t;



typedef struct
{
    thinker_t	thinker;
    sector_t*	sector;
    int			count;
    int			maxlight;
    int			minlight;
    int			maxtime;
    int			mintime;

} lightflash_t;



typedef struct
{
    thinker_t	thinker;
    sector_t*	sector;
    int			count;
    int			minlight;
    int			maxlight;
    int			darktime;
    int			brighttime;

} strobe_t;




typedef struct
{
    thinker_t	thinker;
    sector_t*	sector;
    int			minlight;
    int			maxlight;
    int			direction;

} glow_t;


#define GLOWSPEED						8
#define STROBEBRIGHT			5
#define FASTDARK						15
#define SLOWDARK						35

void	P_SpawnFireFlicker (sector_t* sector);
void	T_LightFlash (lightflash_t* flash);
void	P_SpawnLightFlash (sector_t* sector);
void	T_StrobeFlash (strobe_t* flash);

void
P_SpawnStrobeFlash
( sector_t*		sector,
  int			fastOrSlow,
  int			inSync );

void	EV_StartLightStrobing(line_t* line);
void	EV_TurnTagLightsOff(line_t* line);

void
EV_LightTurnOn
( line_t*		line,
  int			bright );

void	T_Glow(glow_t* g);
void	P_SpawnGlowingLight(sector_t* sector);




//
// P_SWITCH
//
typedef struct
{
    char		name1[9];
    char		name2[9];
    short		episode;

} switchlist_t;


typedef enum
{
    top,
    middle,
    bottom

} bwhere_e;


typedef struct
{
    line_t*		line;
    bwhere_e	where;
    int			btexture;
    int			btimer;
    mobj_t*		soundorg;

} button_t;




// max # of wall switches in a level
#define MAXSWITCHES				50

// 4 players, 4 buttons each at once, max.
#define MAXBUTTONS				16

// 1 second, in ticks.
#define BUTTONTIME		35

extern button_t buttonlist[MAXBUTTONS];

void
P_ChangeSwitchTexture
( line_t*		line,
  int			useAgain );

void P_InitSwitchList(void);


//
// P_PLATS
//
typedef enum
{
    up,
    down,
    waiting,
    in_stasis

} plat_e;



typedef enum
{
    perpetualRaise,
    downWaitUpStay,
    raiseAndChange,
    raiseToNearestAndChange,
    blazeDWUS

} plattype_e;



typedef struct
{
    thinker_t	thinker;
    sector_t*	sector;
    fixed_t		speed;
    fixed_t		low;
    fixed_t		high;
    int			wait;
    int			count;
    plat_e		status;
    plat_e		oldstatus;
    boolean		crush;
    int			tag;
    plattype_e	type;

} plat_t;



#define PLATWAIT				3
#define PLATSPEED				FRACUNIT
#define MAXPLATS				30


extern plat_t*	activeplats[MAXPLATS];

void	T_PlatRaise(plat_t*		plat);

int
EV_DoPlat
( line_t*		line,
  plattype_e	type,
  int			amount );

void	P_AddActivePlat(plat_t* plat);
void	P_RemoveActivePlat(plat_t* plat);
void	EV_StopPlat(line_t* line);
void	P_ActivateInStasis(int tag);


//
// P_DOORS
//
typedef enum
{
    normal,
    close30ThenOpen,
    close,
    open,
    raiseIn5Mins,
    blazeRaise,
    blazeOpen,
    blazeClose

} vldoor_e;



typedef struct
{
    thinker_t	thinker;
    vldoor_e	type;
    sector_t*	sector;
    fixed_t		topheight;
    fixed_t		speed;

    // 1 = up, 0 = waiting at top, -1 = down
    int				direction;

    // tics to wait at the top
    int				topwait;
    // (keep in case a door going down is reset)
    // when it reaches 0, start going down
    int				topcountdown;

} vldoor_t;



#define VDOORSPEED				FRACUNIT*2
#define VDOORWAIT				150

void
EV_VerticalDoor
( line_t*		line,
  mobj_t*		thing );

int
EV_DoDoor
( line_t*		line,
  vldoor_e		type );

int
EV_DoLockedDoor
( line_t*		line,
  vldoor_e		type,
  mobj_t*		thing );

void	T_VerticalDoor (vldoor_t* door);
void	P_SpawnDoorCloseIn30 (sector_t* sec);

void
P_SpawnDoorRaiseIn5Mins
( sector_t*		sec,
  int			secnum );



#if 0 // UNUSED
//
//		Sliding doors...
//
typedef enum
{
    sd_opening,
    sd_waiting,
    sd_closing

} sd_e;



typedef enum
{
    sdt_openOnly,
    sdt_closeOnly,
    sdt_openAndClose

} sdt_e;




typedef struct
{
    thinker_t	thinker;
    sdt_e		type;
    line_t*		line;
    int			frame;
    int			whichDoorIndex;
    int			timer;
    sector_t*	frontsector;
    sector_t*	backsector;
    sd_e		 status;

} slidedoor_t;



typedef struct
{
    char		frontFrame1[9];
    char		frontFrame2[9];
    char		frontFrame3[9];
    char		frontFrame4[9];
    char		backFrame1[9];
    char		backFrame2[9];
    char		backFrame3[9];
    char		backFrame4[9];

} slidename_t;



typedef struct
{
    int				frontFrames[4];
    int				backFrames[4];

} slideframe_t;



// how many frames of animation
#define SNUMFRAMES				4

#define SDOORWAIT				35*3
#define SWAITTICS				4

// how many diff. types of anims
#define MAXSLIDEDOORS	5

void P_InitSlidingDoorFrames(void);

void
EV_SlidingDoor
( line_t*		line,
  mobj_t*		thing );
#endif



//
// P_CEILNG
//
typedef enum
{
    lowerToFloor,
    raiseToHighest,
    lowerAndCrush,
    crushAndRaise,
    fastCrushAndRaise,
    silentCrushAndRaise

} ceiling_e;



typedef struct
{
    thinker_t	thinker;
    ceiling_e	type;
    sector_t*	sector;
    fixed_t		bottomheight;
    fixed_t		topheight;
    fixed_t		speed;
    boolean		crush;

    // 1 = up, 0 = waiting, -1 = down
    int			direction;

    // ID
    int			tag;
    int			olddirection;

} ceiling_t;





#define CEILSPEED				FRACUNIT
#define CEILWAIT				150
#define MAXCEILINGS				30

extern ceiling_t*		activeceilings[MAXCEILINGS];

int
EV_DoCeiling
( line_t*		line,
  ceiling_e		type );

void	T_MoveCeiling (ceiling_t* ceiling);
void	P_AddActiveCeiling(ceiling_t* c);
void	P_RemoveActiveCeiling(ceiling_t* c);
int		EV_CeilingCrushStop(line_t* line);
void	P_ActivateInStasisCeiling(line_t* line);


//
// P_FLOOR
//
typedef enum
{
    // lower floor to highest surrounding floor
    lowerFloor,

    // lower floor to lowest surrounding floor
    lowerFloorToLowest,

    // lower floor to highest surrounding floor VERY FAST
    turboLower,

    // raise floor to lowest surrounding CEILING
    raiseFloor,

    // raise floor to next highest surrounding floor
    raiseFloorToNearest,

    // raise floor to shortest height texture around it
    raiseToTexture,

    // lower floor to lowest surrounding floor
    //	and change floorpic
    lowerAndChange,

    raiseFloor24,
    raiseFloor24AndChange,
    raiseFloorCrush,

    // raise to next highest floor, turbo-speed
    raiseFloorTurbo,
    donutRaise,
    raiseFloor512

} floor_e;




typedef enum
{
    build8,		// slowly build by 8
    turbo16		// quickly build by 16

} stair_e;



typedef struct
{
    thinker_t	thinker;
    floor_e		type;
    boolean		crush;
    sector_t*	sector;
    int			direction;
    int			newspecial;
    short		texture;
    fixed_t		floordestheight;
    fixed_t		speed;

} floormove_t;



#define FLOORSPEED				FRACUNIT

typedef enum
{
    ok,
    crushed,
    pastdest

} result_e;

result_e
T_MovePlane
( sector_t*		sector,
  fixed_t		speed,
  fixed_t		dest,
  boolean		crush,
  int			floorOrCeiling,
  int			direction );

int
EV_BuildStairs
( line_t*		line,
  stair_e		type );

int
EV_DoFloor
( line_t*		line,
  floor_e		floortype );

void T_MoveFloor( floormove_t* floor);

//
// P_TELEPT
//
int
EV_Teleport
( line_t*		line,
  int			side,
  mobj_t*		thing );

#endif
//-----------------------------------------------------------------------------
//
// $Log:$
//
//-----------------------------------------------------------------------------
